﻿using System;
using System.Linq;
using System.Linq.Expressions;
using Infrastructure;
using Microsoft.EntityFrameworkCore;
using OpenAuth.Repository.Core;
using OpenAuth.Repository.Interface;
using Z.EntityFramework.Plus;//https://www.cnblogs.com/yaopengfei/archive/2018/06/26/9226328.html ef性能增强组件

namespace OpenAuth.Repository
{
    #region 为什么用树表达式
    //在.NET中，对‘Where’至少有两个重写方法：
    //public static IQueryable Where(this IQueryable source, Expression> predicate);
    //public static IEnumerable Where(this IEnumerable source, Func predicate);
    //现在我们正在使用的是
    //Func<T, bool>
    //现在的查询将会使用'IEnumerable'版本，在示例中，首先从数据库中取出整个表的记录，然后再执行过滤条件取得最终的结果。想要证明这一点，只要去看看生成的sql语句，它是不包含Where字句的。
    //若要解决这个问题，我们需要修改'Func' to 'Expression Func'.
    //Expression<Func<T, bool>> predicate
    //现在 'Where'方法使用的就是 'IQueryable'版本了。
    //Note: 因此看来，使用 Expression Func 比起使用 Func是更好的主意.
    //现在使用通用的仓储类，我们需要创建一个对应的工作单元类。这个工作单元类将检查仓储类是否已经创建，如果存在将返回一个实例，否则将创建一个新的实例。
    #endregion

    public  class CisRepository<T> :ICisRepository<T> where T :class
   {
       private CisDBContext _context;

       public CisRepository(CisDBContext context)
       {
           _context = context;
           
       }


       /// <summary>
        /// 根据过滤条件，获取记录
        /// </summary>
        /// <param name="exp">The exp.</param>
        public IQueryable<T> Find(Expression<Func<T, bool>> exp = null)
        {
            return Filter(exp);
        }

        public bool IsExist(Expression<Func<T, bool>> exp)
        {
            return _context.Set<T>().Any(exp);
        }

        /// <summary>
        /// 查找单个，且不被上下文所跟踪
        /// </summary>
        public T FindSingle(Expression<Func<T, bool>> exp)
        {
            //只能用于查询，不能把查询后的实体用作其他的用途，不然会导致其他的错误。例如：我想查询数据库有没有一条数据，用AsNotracking()查询后，如果有就把他赋值给一个实体，如果没有就new一个新实体。这样的话，因为AsNotracking()没有把这个实体加到EF跟踪里面，EF就会认为这个实体在数据库不存在，就会把查询后的实体添加到数据库，但是实际情况是这个实体是存在于数据库里面的，这样就会报数据重复的错误。所以使用AsNotracking()只能用于查询，不能用于其他赋值的操作
            //FirstOrDefault(exp); 取序列中满足条件的第一个元素，如果没有元素满足条件，则返回默认值（对于可以为null的对象，默认值为null，对于不能为null的对象，如int，默认值为0）

            return _context.Set<T>().AsNoTracking().FirstOrDefault(exp);
        }

        /// <summary>
        /// 得到分页记录
        /// </summary>
        /// <param name="pageindex">The pageindex.</param>
        /// <param name="pagesize">The pagesize.</param>
        /// <param name="orderby">排序，格式如："Id"/"Id descending"</param>
        public IQueryable<T> Find(int pageindex, int pagesize, string orderby = "", Expression<Func<T, bool>> exp = null)
        {
            if (pageindex < 1) pageindex = 1;
            if (string.IsNullOrEmpty(orderby))
                orderby = "Id descending";

            return Filter(exp).OrderBy(orderby).Skip(pagesize * (pageindex - 1)).Take(pagesize);
        }

        /// <summary>
        /// 根据过滤条件获取记录数
        /// </summary>
        public int GetCount(Expression<Func<T, bool>> exp = null)
        {
            return Filter(exp).Count();
        }

        public void Add(T entity)
        {
            //if (string.IsNullOrEmpty(entity.Id))
            //{
            //    entity.Id = Guid.NewGuid().ToString();

            //}

            _context.Set<T>().Add(entity);
            Save();

            _context.Entry(entity).State = EntityState.Detached;
        }

        /// <summary>
        /// 批量添加
        /// </summary>
        /// <param name="entities">The entities.</param>
        //public void BatchAdd(T[] entities)
        //{
        //    foreach (var entity in entities)
        //    {
        //        entity.Id = Guid.NewGuid().ToString();
        //    }
        //    _context.Set<T>().AddRange(entities);
        //    Save();
        //}

        public void Update(T entity)
        {
            var entry = this._context.Entry(entity);
            entry.State = EntityState.Modified;

            //如果数据没有发生变化
            if (!this._context.ChangeTracker.HasChanges())
            {
                return;
            }

            Save();
        }

        public void Delete(T entity)
        {
            _context.Set<T>().Remove(entity);
            Save();
        }


        /// <summary>
        /// 实现按需要只更新部分更新
        /// <para>如：Update(u =>u.Id==1,u =>new User{Name="ok"});</para>
        /// </summary>
        /// <param name="where">The where.</param>
        /// <param name="entity">The entity.</param>
        public void Update(Expression<Func<T, bool>> where, Expression<Func<T, T>> entity)
        {
           _context.Set<T>().Where(where).Update(entity);
        }

        public virtual void Delete(Expression<Func<T, bool>> exp)
        {
            _context.Set<T>().Where(exp).Delete();
        }

        public void Save()
        {
            //try
            //{
                _context.SaveChanges();
            //}
            //catch (DbEntityValidationException e)
            //{
            //    throw new Exception(e.EntityValidationErrors.First().ValidationErrors.First().ErrorMessage);
            //}
        }

        private IQueryable<T> Filter(Expression<Func<T, bool>> exp)
        {
            var dbSet = _context.Set<T>().AsNoTracking().AsQueryable();
            if (exp != null)
                dbSet = dbSet.Where(exp);
            return dbSet;
        }

       public int ExecuteSql(string sql)
       {
          return  _context.Database.ExecuteSqlCommand(sql);
       }
   }
}
